/**
 * 请求拦截
 * @param {Object} http
 */


import { getToken } from '@/common/api'
// 是否正在刷新token的标记
let isRefreshing = false
// 重试请求队列
let requests = []
/**
 * 请求拦截
 * @param {Object} http
 */

module.exports = (vm) => {
	// const tenantId = uni.getStorageSync("tenantId") ? uni.getStorageSync("tenantId") : 1
    uni.$u.http.interceptors.request.use((config) => { // 可使用async await 做异步操作
        // 初始化请求拦截器时，会执行此方法，此时data为undefined，赋予默认{}
		
        config.data = config.data || {}
        // 可以在此通过vm引用vuex中的变量，具体值在vm.$store.state中
        // console.log(vm.$store.state);
		config.header = {
		    // 'content-type': 'application/x-www-form-urlencoded',
		    // 'content-type': 'application/json',
			'tenant-id': 1,
			'Authorization': vm.vuex_token
		};
        return config
    }, (config) => // 可使用async await 做异步操作
        Promise.reject(config))

	  // 响应拦截
	  uni.$u.http.interceptors.response.use(
	   async (response) => {
	      /* 对响应成功做点什么 可使用async await 做异步操作*/
	      const data = response.data
		 
		  // 自定义参数
		  const custom = response.config?.custom
		  if (data.code !== 0 && data.code !== 401 && data.code !== 400) { // 服务端返回的状态码不等于200，则reject()
		      // 如果没有显式定义custom的toast参数为false的话，默认对报错进行toast弹出提示
		      if (custom.toast !== false) {
		          uni.$u.toast(data.msg || '请求超时或服务器异常')
		      }
		      // 如果需要catch返回，则进行reject
		      if (custom?.catch) {
		          return Promise.reject(data)
		      } else {
		          // 否则返回一个pending中的promise
		          return new Promise(() => { })
		      }
		  }
		  if (data.code == 400) {
		  			   console.log(data,'无效的刷新令牌')
		  			   if(data.msg == "无效的刷新令牌"){
		  				   uni.$u.toast(data.msg)
						   uni.removeStorageSync('userInfo');
						   uni.removeStorageSync('expiresTime');
						   uni.removeStorageSync('refreshToken');
						   uni.removeStorageSync('openId');
						   uni.removeStorageSync('planData');
						   uni.removeStorageSync('duibi');
						   // vm.vuex('vuex_token', '')
						   uni.$u.vuex('vuex_token', '')
						   // vm.vuex('vuex_user', '')
						   uni.$u.vuex('vuex_user', '')
		  				   uni.navigateTo({
		  				   	url:"/pages/login/login"
		  				   })
		  				   return
		  			   }
		  		
		  }
		   if (data.code == 401) {
			   // console.log(data)
			   // if(data.msg == "账号未登录"){
				  //  uni.$u.toast(data.msg)
				  //  uni.navigateTo({
				  //  	url:"/pages/login/login"
				  //  })
				  //  return
			   // }
			   if (!isRefreshing) {
			     // 正在刷新
			     isRefreshing = true
			     await getToken({'refreshToken':uni.getStorageSync('refreshToken')}).then(res=>{
					 uni.$u.vuex('vuex_token', res.accessToken)
					 uni.setStorageSync('refreshToken', res.refreshToken)
					 uni.setStorageSync('expiresTime', res.expiresTime)
				 })
			     requests.forEach(async ({ fn, resolve }) => {
			       // 逐个按请求队列顺序重新发起请求
			       const res = await fn()
			       resolve(res)
			     })
			     requests = [] // 清空请求队列
			     return uni.$u.http.request(response.config)
			   } else {
			     // 同时并发出现的请求 新的token没回来之前 先用promise 存入等待队列中
			     return new Promise((resolve) => {
			       const fn = () => Promise.resolve(uni.$u.http.request(response.config))
			       requests.push({ fn, resolve })
			     })
			   }
		   }
		  return data.data || {}
		  
	      // if (!data.data || !data.stauts){
	      //   // 自定义参数
	      //   const custom = response.config.custom
	      //   // 如果没有显式定义custom的toast参数为false的话，默认对报错进行toast弹出提示
	      //   if (custom.toast) uni.$u.toast(data.message || '请求超时或服务器异常')
	      //   // 如果需要catch返回，则进行reject
	      //   if (custom.catch) return Promise.reject(data)
	      //   else return new Promise(() => {}) // 否则返回一个pending中的promise，请求不会进入catch中
	      // }
	      // return data.data ? data.data : data
	    },
	   //  async (response) => {
			 // console.log(response.statusCode,"#$$$$$$$$$$$$$$$$$$1")
	   //    switch (response.statusCode) {
	   //      case 401:
	   //        if (!isRefreshing) {
	   //          // 正在刷新
	   //          isRefreshing = true
	   //          await getToken({'refreshToken':uni.getStorageSync('refreshToken')})
	   //          requests.forEach(async ({ fn, resolve }) => {
	   //            // 逐个按请求队列顺序重新发起请求
	   //            const res = await fn()
	   //            resolve(res)
	   //          })
	   //          requests = [] // 清空请求队列
	   //          return uni.$u.http.request(response.config)
	   //        } else {
	   //          // 同时并发出现的请求 新的token没回来之前 先用promise 存入等待队列中
	   //          return new Promise((resolve) => {
	   //            const fn = () => Promise.resolve(uni.$u.http.request(response.config))
	   //            requests.push({ fn, resolve })
	   //          })
	   //        }
	   //      default:
	   //        return uni.$u.toast(response.data.msg || '请求超时或服务器异常')
	   //    }
	   //  }
	  )
	
}

